package com.aerospike.client;

import org.junit.Test;
import org.junit.Before;
import static org.junit.Assert.*;
import com.aerospike.client.Value;

/**
 * Unit tests for Value.ShortValue.equals(...)
 *
 * Note: These tests exercise the equals implementation of the nested
 * ShortValue class in com.aerospike.client.Value.
 */
public class ValueTest {
    private Value.ShortValue instance;

    @Before
    public void setUp() {
        instance = new Value.ShortValue((short) 5);
    }

    @Test
    public void testSameInstance_equalsTrue() {
        // same instance should be equal to itself
        assertTrue(instance.equals(instance));
    }

    @Test
    public void testEqualValues_symmetry() {
        // two distinct ShortValue instances with same short value should be equal (symmetry)
        Value.ShortValue a = new Value.ShortValue((short) 123);
        Value.ShortValue b = new Value.ShortValue((short) 123);
        assertTrue(a.equals(b));
        assertTrue(b.equals(a));
    }

    @Test
    public void testDifferentValues_equalsFalse() {
        Value.ShortValue a = new Value.ShortValue((short) 10);
        Value.ShortValue b = new Value.ShortValue((short) 11);
        assertFalse(a.equals(b));
    }

    @Test
    public void testNullComparison_returnsFalse() {
        // comparing to null must return false
        assertFalse(instance.equals(null));
    }

    @Test
    public void testDifferentType_returnsFalse() {
        // comparing to an unrelated type (e.g., java.lang.Short) must return false
        Short boxed = (short) 5;
        assertFalse(instance.equals(boxed));
    }

    @Test
    public void testBoundaryMin_equalsTrue() {
        Value.ShortValue a = new Value.ShortValue(Short.MIN_VALUE);
        Value.ShortValue b = new Value.ShortValue(Short.MIN_VALUE);
        assertTrue(a.equals(b));
    }

    @Test
    public void testBoundaryMax_equalsTrue() {
        Value.ShortValue a = new Value.ShortValue(Short.MAX_VALUE);
        Value.ShortValue b = new Value.ShortValue(Short.MAX_VALUE);
        assertTrue(a.equals(b));
    }

    @Test
    public void testManyComparisons_performanceNoException() {
        // Perform a large number of comparisons to ensure stability/performance.
        // This is not a strict performance benchmark, but helps detect issues under load.
        Value.ShortValue a = new Value.ShortValue((short) 42);
        Value.ShortValue b = new Value.ShortValue((short) 42);
        for (int i = 0; i < 100_000; i++) {
            // single assertion per loop would be too slow; just ensure equals returns true each time
            if (!a.equals(b)) {
                fail("Equality failed during repeated comparisons at iteration: " + i);
            }
        }
        // If loop completes, consider test passed.
        assertTrue(true);
    }
}

package com.aerospike.client;

import org.junit.Test;
import org.junit.Before;
import static org.junit.Assert.*;
import com.aerospike.client.Value;

public class ValueTest {
    private Value shortOne;

    @Before
    public void setUp() {
        // Create a Value instance representing a short. Use factory method to obtain concrete implementation.
        shortOne = Value.get((short)1);
    }

    @Test
    public void testShortValue_Equals_SameInstance_True() {
        // same instance must be equal to itself
        assertTrue(shortOne.equals(shortOne));
    }

    @Test
    public void testShortValue_Equals_SameValueDifferentInstances_True() {
        // Two distinct Value instances created for the same short value should be equal.
        Value a = Value.get((short)42);
        Value b = Value.get((short)42);
        assertTrue(a.equals(b));
        assertTrue(b.equals(a)); // symmetry
    }

    @Test
    public void testShortValue_Equals_DifferentShortValues_False() {
        // Values with different short contents must not be equal.
        Value a = Value.get((short)42);
        Value b = Value.get((short)43);
        assertFalse(a.equals(b));
        assertFalse(b.equals(a));
    }

    @Test
    public void testShortValue_Equals_Null_False() {
        // equals with null must return false
        Value v = Value.get((short)0);
        assertFalse(v.equals(null));
    }

    @Test
    public void testShortValue_Equals_DifferentNumericType_False() {
        // A short Value should not be equal to an int Value even if numeric values are the same.
        Value shortVal = Value.get((short)1);
        Value intVal = Value.get(1); // int factory
        assertFalse(shortVal.equals(intVal));
        assertFalse(intVal.equals(shortVal));
    }

    @Test
    public void testShortValue_Equals_OtherObjectType_False() {
        // equals must return false for arbitrary other object types
        Value v = Value.get((short)5);
        Object other = new Object();
        assertFalse(v.equals(other));
    }

    @Test
    public void testShortValue_Equals_BoundaryValues() {
        // Test boundary short values
        Value minValA = Value.get(Short.MIN_VALUE);
        Value minValB = Value.get((short)Short.MIN_VALUE);
        Value maxValA = Value.get(Short.MAX_VALUE);
        Value maxValB = Value.get((short)Short.MAX_VALUE);

        assertTrue(minValA.equals(minValB));
        assertTrue(minValB.equals(minValA));
        assertTrue(maxValA.equals(maxValB));
        assertTrue(maxValB.equals(maxValA));

        assertFalse(minValA.equals(maxValA));
        assertFalse(maxValA.equals(minValA));
    }

    @Test
    public void testShortValue_Equals_Transitivity() {
        // If a == b and b == c then a == c
        Value a = Value.get((short)123);
        Value b = Value.get((short)123);
        Value c = Value.get((short)123);

        assertTrue(a.equals(b));
        assertTrue(b.equals(c));
        assertTrue(a.equals(c));
    }

    @Test
    public void testShortValue_Equals_LargeScale_RepeatedComparisons() {
        // Run repeated equality checks to simulate large-scale usage.
        // This is not a strict performance benchmark but verifies consistent behavior under load.
        Value v1 = Value.get((short)100);
        // Pre-create an array of same-value Value objects to compare against.
        final int iterations = 10000;
        Value[] arr = new Value[iterations];
        for (int i = 0; i < iterations; i++) {
            arr[i] = Value.get((short)100);
        }

        for (int i = 0; i < iterations; i++) {
            if (!v1.equals(arr[i])) {
                fail("Equality mismatch at iteration " + i);
            }
        }

        // Final assertion to indicate test passed if no failures occurred.
        assertTrue(true);
    }
}